System and method for caching results

ABSTRACT

In certain aspects, the invention features a system and method for caching results, including receiving a job for computation by a distributed computing system having one or more node computing devices in communication with a cache, processing, on one of the node computing devices, the job to create an intermediate result for storage in the cache, wherein the intermediate result includes data wherein a time required to obtain the data by computation or retrieval from a data storage external to the distributed computer system is at least marginally greater than that of retrieving the intermediate result from the cache. In accordance with such aspects, the system and method further includes storing the intermediate result in the cache, and accessing the cache by presenting a lookup function to the cache, wherein the lookup function includes a key and a compute function configured to produce the intermediate result.

CROSS-REFERENCE TO RELATED APPLICATIONS

This application is a continuation of application Ser. No. 11/040,715,filed Jan. 21, 2005, now U.S. Pat. No. 7,240,158, which is a divisionalof application Ser. No. 10/177,497, filed Jun. 21, 2002, now U.S. Pat.No. 6,895,472; the entirety of the foregoing related applications andpatents are incorporated by reference herein.

BACKGROUND

I. Field of the Invention

The present invention relates to the structure and operation ofcomputing systems, and more particularly, to distributed computingsystems and methods of operating such systems.

II. Description of the Related Art

Certain organizations have a need for high performance computingresources. For example, a financial institution may use such resourcesto perform risk management modeling of the valuations for particularinstruments and portfolios at specified states of the world. As anotherexample, a pharmaceutical manufacturer may use high performancecomputing resources to model the effects, efficacy and/or interactionsof new drugs it is developing. As a further example, an oil explorationcompany may evaluate seismic information using high performancecomputing resources.

One conventional computing system includes a mainframe computer attachedto an individual user terminal by a network connection. Using theterminal, a user may instruct the mainframe computer to execute acommand. In this conventional system, almost all data storage andprocessing functionality resides on the mainframe computer, whilerelatively little memory or processing capability exists at theterminal. This terminal/mainframe architecture may not, however, allowcomputations requested by a user to be computed rapidly orautomatically.

The open systems interconnection (OSI) model describes one conceptualnetwork architecture represented by seven functional layers. In thismodel, the functions of a networking system in a data communicationsnetwork are reflected as a set of seven layers, including a physicallayer, data link layer, network layer, transport layer, session layer,presentation layer and application layer. One or more entities withineach layer implement the functionality of the layer. Each entityprovides facilities for use only by the layer above it, and interactsdirectly only with the layer below it. FIG. 1 depicts the sevenfunctional layers of the OSI model.

The physical layer describes the physical characteristics of hardwarecomponents used to form a network. For example, the size of cable, thetype of connector, and the method of termination are defined in thephysical layer.

The data link layer describes the organization of the data to betransmitted over the particular mechanical/electrical/optical devicesdescribed in the physical layer. For example, the framing, addressingand check summing of Ethernet packets is defined in the data link layer.

The network layer describes how data is physically routed and exchangedalong a path for delivery from one node of a network to another. Forexample, the addressing and routing structure of the network is definedin this layer.

The transport layer describes means used to ensure that data isdelivered from place to place in a sequential, error-free, and robust(i.e., no losses or duplications) condition. The complexity of thetransport protocol is defined by the transport layer.

The session layer involves the organization of data generated byprocesses running on multiple nodes of a network in order to establish,use and terminate a connection between those nodes. For example, thesession layer describes how security, name recognition and loggingfunctions are to take place to allow a connection to be established,used and terminated.

The presentation layer describes the format the data presented to theapplication layer must possess. This layer translates data from theformat it possesses at the sending/receiving station of the network nodeto the format it must embody to be used by the application layer.

The application layer describes the service made available to the userof the network node in order to perform a particular function the userwants to have performed. For example, the application layer implementselectronic messaging (such as “e-mail”) or remote file access.

In certain conventional high performance computing systems designedusing the OSI model, the hardware used for computation-intensiveprocessing may be dedicated to only one long-running program and,accordingly, may not be accessible by other long running programs.Moreover, it may be difficult to easily and dynamically reallocate thecomputation-intensive processing from one long running program toanother. In the event processing resources are to be reallocated, aprogram currently running on a conventional high performance computersystem typically must be terminated and re-run in its entirety at alater time.

SUMMARY OF THE INVENTION

In one aspect, the invention features a method including receiving a jobfor computation by a distributed computing system having one or morenode computing devices in communication with a cache, processing, on oneof the node computing devices, the job to create an intermediate resultfor storage in the cache, wherein the intermediate result includes datawherein a time required to obtain the data by computation or retrievalfrom a data storage external to the distributed computer system is atleast marginally greater than that of retrieving the intermediate resultfrom the cache. In accordance with such an aspect, the method furtherincludes storing the intermediate result in the cache, and accessing thecache by presenting a lookup function to the cache, wherein the lookupfunction includes a key and a compute function configured to produce theintermediate result.

In another aspect, the invention features a distributed computing systemincluding one or more node computing devices in communication with acache, means for receiving a job for computation by the distributedcomputing system, means for processing, on one of the node computingdevices, the job to create an intermediate result for storage in thecache, wherein the intermediate result includes data wherein a timerequired to obtain the data by computation or retrieval from a datastorage external to the distributed computer system is at leastmarginally greater than that of retrieving the intermediate result fromthe cache. According to such an aspect, the system further includesmeans for storing the intermediate result in the cache, and means foraccessing the cache by presenting a lookup function to the cache,wherein the lookup function includes a key and a compute functionconfigured to produce the intermediate result.

BRIEF DESCRIPTION OF THE DRAWINGS

Features and other aspects of the invention are explained in thefollowing description taken in conjunction with the accompanyingdrawings, wherein:

FIG. 1 depicts the seven functional layers of the open systemsinterconnection (OSI) model;

FIG. 2 illustrates a system 10 including a compute backbone 300according to one embodiment of the present invention;

FIG. 3 illustrates certain components of one embodiment of a localcomputer 100 of the system 10 shown in FIG. 2;

FIG. 4 illustrates certain components of one embodiment of a transactionmanager 400 of the system 10 shown in FIG. 2;

FIG. 5 illustrates certain components of one embodiment of a scheduler600 of the system 10 shown in FIG. 2;

FIG. 6 illustrates certain components of one embodiment of a servicemanager 700 of the system 10 shown in FIG. 2;

FIG. 7 illustrates certain components of one embodiment of a nodecomputer 800 of the system 10 shown in FIG. 2;

FIGS. 8 a and 8 b illustrate one embodiment of a method of executing acomputing application using the system shown in FIG. 2.

FIG. 9 illustrates one embodiment of a method of distributingcomputations using the system 10 shown in FIG. 2;

FIGS. 10 a and 10 b illustrate one embodiment of a method of cachingresults using the system 10 shown in FIG. 2; and

FIG. 11 illustrates one embodiment of a method of debugging using thesystem 10 shown in FIG. 2.

It is to be understood that the drawings are exemplary, and are notlimiting.

DETAILED DESCRIPTION OF PREFERRED EMBODIMENTS

Various embodiments of the present invention will now be described ingreater detail with reference to the drawings.

I. System Embodiments of the Invention

FIG. 2 illustrates certain components of one embodiment of a system 10of the present invention, which may generally include a number of localcomputers 100-1 to 100-N in communication, via a network 200, with acompute backbone 300.

A function of this embodiment of the system 10 is to service parametriccomputation requests of various users 20 or groups of users. Inparticular, such a system 10 may allow each user 20 access to a serviceon a common infrastructure for performing compute dense calculations bydynamically allocating a portion of the compute backbone 300infrastructure to the user 20 for processing of each user's 20 distinctapplication. A system 10 of one embodiment may include software thatallows compute intensive applications to queue, schedule and prioritizetheir calculations on the infrastructure. In addition, theinfrastructure and software of such an embodiment may operate to manageresource allocation, authentication, job distribution, data flow andfault tolerance. In accordance with this system 10, distinctapplications may each connect to the compute backbone 300infrastructure, which may perform several operations includingprioritizing compute requests from the applications according to apolicy (predetermined or otherwise), allocating hardware and softwareresources, assigning compute requests to a proper computation resource,and returning results to the applications.

A. Local Computer 100

In the embodiment depicted in FIGS. 2 and 3, each local computer 100 maygenerally include one or more data storage devices 110, a centralprocessing unit (CPU) 120, one or more input devices 130, one or moreoutput devices 140, input/output (I/O) communications ports 150, andother hardware components (not shown) which facilitate performance ofthe functions of the local computer 100 and/or the system 10 asdescribed herein. In one embodiment, the hardware devices of a localcomputer 100 may be in communication with one another by a shared databus and/or by dedicated connections (not shown). In addition, a numberof software components 160 may run on each local computer 100.

A local computer 100-1 of one embodiment may be, for example, a sharedmemory multiprocessor machine made by Sun Microsystems configured to runprograms created using the Smalltalk programming language. Anotherembodiment of a local computer 100-2 may be an IBM machine runningprograms created using the C programming language. Yet anotherembodiment of a local computer 100-3 may be an SGI machine runningprograms using the C++ and/or Java programming languages. A furtherembodiment of a local computer 100-4 may include a composition of anumber of separate devices.

The data storage devices 110 of one embodiment may include one or morehard disk drives. However, it is to be understood that data storagedevices 110 such as RAM, ROM, CD-ROM, DVD-ROM, solid state drive, floppydisk-drive or combinations thereof may also be included in theembodiment shown in FIG. 3, or in certain other appropriate embodiments.One embodiment of a local computer 100-1 may include input device(s) 130(e.g., keyboard, pointing/selecting device such as a mouse or trackball, floppy disk-drive, scanner and/or touch screen interface) that mayenable a user 20 and/or applications developer 30 of the system 10 toprovide information and instructions for storage in the local computer100 and use in operation of the system 10. An embodiment of a localcomputer 100-1 may also include output devices 140 (e.g., printer,display device, floppy disk-drive and/or computer monitor) that mayenable a user 20 and/or applications developer 30 to receive, forfurther manipulation and/or storage, information generated using thelocal computer 100 and/or the system 10. The I/O communications ports150 of a local computer 100-1 of one embodiment may be serial andparallel, and may be configured to include multiple communicationschannels for simultaneous connections. The software components 160 mayinclude an operating system 170 (e.g., Linux, Unix, Microsoft WindowsNT), one or more user interface tools 175, calling applications 180, andan application program interface (API) 190. One embodiment of the system10 may include ten or more local computers 100-1 to 100-N.

i. Calling Application 180

In one embodiment, a calling application 180 may be a computer programthat contains logic to achieve or produce an outcome for a user 20. Thesoftware architecture of certain applications may conceptually consistof four layers: user interface and ad hoc calculation tools; logic;persistence; and high performance computing. The user 20 may sendcertain computation intensive portions of a particular callingapplication 180 (i.e., the high performance computing layer) to thecompute backbone 300 for processing rather than have the local computer100 process those computation intensive portions. In accordance with oneembodiment, the user 20 may do so by (i) creating one or more workermodules 195-1 to 195-N (e.g., shared libraries, executable filescompliant with a compute backbone 300, Java archive files and/or otherarchive files), each of which contains one or more compute functions orengines called “workers” 155-1 to 155-N, (ii) deploying the workermodules 195-1 to 195-N on the compute backbone 300, and (iii) sending tothe compute backbone 300 a job 182 that requests the compute backbone300 to perform a computation using a worker 155 contained in a workermodule 195 that has been deployed on the compute backbone 300. A worker155 may be constructed to conform to and operate with the API 190, andmay conceptually “plug” into the infrastructure of the compute backbone300 (in particular, to the launcher 880 as described below in sectionv.). A compute function may be implemented in a number of waysincluding, without limitation, as a function, as a class method or as anexecutable constructed to be compatible with the compute backbone 300.In accordance with one embodiment, a worker 155 may be capable ofstaying initialized after completing a computation in order to handleadditional compute requests should the scheduler 600 send such requeststo the node computer 800 on which the worker 155 is invoked.

According to one embodiment, a worker 155 may be capable of computingtasks 186-1 to 186-N once loaded onto the compute backbone 300. Forexample, a worker 155 may be a function that takes task inputs andreturns a task output or an error indication. Furthermore, a worker 155may itself create a job 182 and schedule tasks 186-1 to 186-N with thecompute backbone 300, thereby further subdividing computations to beperformed.

A job 182 may be conceptualized as a means for opening or establishing acomputation session with the infrastructure of the compute backbone 300.In one embodiment, a job 182 may include and supply to the computebackbone 300 certain defining requirements or parameters for acomputation session. In particular, one embodiment of a job 182 mayinclude meta-information, such as an identification of a particularworker 155 to be used with the job. In one embodiment, meta-informationsupplied by a job 182 identifies only one worker 155 such that all jobs182-1 to 182-N on the compute backbone may have a generally homogeneousformat. In another embodiment, meta-information supplied by a job 182may identify more than one worker 155-1 to 155-N.

Other optional meta-information may include information about thepriority of the job 182 in relation to other jobs, a specification ofminimal hardware requirements (e.g., minimum RAM and/or CPU power) forthe job 182, a specification of a minimum number of nodes to beallocated in order for the particular job 182 to be run properly orefficiently, the amount of debugging information the job 182 is toprovide while it is running, and task logic to control sequencing andcontrol of task computation (e.g., fail all tasks if one task fails, onetask is dependent upon another task).

According to one embodiment, certain meta-information may be changedwhile a job 182 is running. For example, the priority of the job 182 maybe adjusted by a user 20 without terminating or suspending the job 182.As another example, a user 20 may modify the amount of debugginginformation the job is to provide while it is running.

In one embodiment, a job 182 may also contain one or more tasks 186 andinputs which collectively represent a unit of computational work to beperformed by a processor. Such inputs may include optional global data.A particular worker 155 of a worker module 195 deployed on the computebackbone 300 may perform each task 186-1 to 186-N. Global data and taskinputs 187-1 to 187-N may combine to represent the inputs to aparticular computation. For example, a job 182 may be defined to computethe value of a number of financial instruments based on the marketconditions at closing time on a particular trading day. A user 20 mayconfigure the job 182 such that the global data for the job 182 definesthe market conditions at closing, and each instrument may be representedby a separate task 186. In such a case, the task inputs 187-1 to 187-Nand global data would be supplied to generate task output 189. However,inputs (e.g., global data and/or task inputs 187-1 to 187-N) need not beprovided to a job 182 at the time the job 182 is created. In addition,tasks 186-1 to 186-N need not be supplied at the time of job 182creation. A job 182 also may have a dynamic collection of one or moretasks 186-1 to 186-N.

A task 186 may be an encapsulation of a single computation to beperformed by the compute backbone 300. A task 186 has an input object187 (i.e., the input needed for a calculation), and on success it willhave an output object or an error indication 189. At any point in time atask 186 also has a state 188, such as an indication of whether the task186 has been completed or not (e.g., queued, running, completed,rescheduled, suspended, or error), and produce log data as generated bythe worker 155. In accordance with one embodiment, a worker 155 on thecompute backbone 300 loads a worker module 195, performs a requestedcomputation, and creates task output 189. In one embodiment, a task 186typically may be completed in two seconds or less, and perhaps in 100milliseconds or less.

In one embodiment, calling applications 180-1 to 180-N running on thelocal computers 100-1 to 100-N are programmed to interface with thecompute backbone 300. In particular, a calling application 180 runningon a particular local computer 100 is compatible with the API 190 alsorunning on that local computer 100. For example, a calling application180 created in C programming language may be compatible with the Clanguage API 190 running on a particular local computer 100. In such anexample, a portion of the API 190 may communicate with both the callingapplication 180 and the compute backbone 300 in the following manner.First, a calling application 180 may send a request, in C language, forsomething to be done by the compute backbone 300 (e.g., a request for acomputation to be performed or for a result to be retrieved). The API190 may translate the C language request into, for example, a languageindependent protocol such as an XML/HTTP protocol request, and then sendit to the compute backbone 300, which in turn processes the request fromthe calling application 180.

ii. Application Program Interface 190

According to one embodiment, an object oriented API 190 residing on alocal computer 100 provides an interface between a calling application180 and the compute backbone 300. Such an API 190 may use a transparentcommunication protocol (e.g., SOAP, XML/HTTP or its variants) to providecommunication between calling applications 180-1 to 180-N and thecompute backbone 300 infrastructure. The API 190 of one embodimentinteracts with the transaction manager 400 to authenticate requests fromcalling applications 180-1 to 180-N for access to the resources of thecompute backbone 300.

Each API 190 contains a minimal but complete set of operations (to beperformed by the compute backbone 300) that supports the job logic ofthe particular calling application 180, as well as the communicationpatterns of the local computer 100 on which the calling application 180is running, such that the API 190 can send computation inputs andretrieve results. Each API 190 has a client 183 embedded in the callingapplication 180. The client 183 communicates with the compute backbone300. Each API 190 also includes a managed service component 198 thatimplements resource allocation, fault tolerance, user acceptance testing(UAT), and release control functions.

The APIs 190-1 to 190-N shown in FIG. 2 need not all be compatible withthe same programming language. For example, one API 190-1 may becompatible with C programming language, while another API 190-2 iscompatible with C++ programming language, while yet another 190-3 iscompatible with Java programming language.

The API 190 assists a calling application 180 in finding and accessing acompute function contained in a worker module 190 deployed on thecompute backbone 300. In particular, the API 190 provides an agent orproxy responsible for performing computations on the compute backbone300, i.e. a worker 155, and defines the way the computation inputs andoutputs are to be communicated. The API 190 also allows users 20-1 to20-N (i) to schedule jobs 182-1 to 182-N (which are associated with aparticular calling application 180) with a worker 155 that resides on anavailable node computer 800 of the compute backbone 300, (ii) to queryand modify the status and priority of the jobs 182-1 to 182-N, and (iii)to terminate running jobs 182-1 to 182-N. The API 190 may also provideworkers 155-1 to 155-N with access to global cache 900 (i.e., persistentstorage) such that the workers 155-1 to 155-N may share intermediatecomputational results. Furthermore, the API 190 may schedule tasks 186-1to 186-N synchronously or asynchronously to allow a calling application180 to either wait for a computation to complete before continuing, orto continue and then poll for results at a later time. An API 190 of oneembodiment may also facilitate the connection of separate callingapplications 180-1 to 180-2 to a job 182 (e.g., one calling application180-1 may submit inputs to a job 182 while another calling application182-2 handles retrieval of results from the job 182).

An API 190 according to one embodiment may also facilitate workers 155themselves becoming clients of the compute backbone 300 to furtherdecompose a particular computation request. For example, an API 190running on a particular local computer 100 may send a request to thecompute backbone 300 to compute the value of a portfolio of instruments.That API 190 may facilitate decomposition of the request into a numberof separate requests which each value one instrument of the portfolio.After the value of each instrument is computed, the compute backbone 300collects the results for delivery back to the local computer 100.

One embodiment of the API 190 is capable of operating in one of twomodes: “network” mode or “local” mode. In local mode, the API 190simulates the compute backbone 300 on a local computer 100 as a closedenvironment. In such a mode of operation, the API 190 initializes aworker module 195 containing a worker 155 in the same process space asthe job 182 making the request (i.e., on the local computer 100 in whichthe particular API 190 and calling application 180 reside), rather thanon a node computer 800 separated from the local computer 100 by, amongother things, a network 200. In local mode, the API 190 makes all of thefunctions performed by the compute backbone 300 (e.g., scheduling,global caching, etc.) available to the worker 155 as if the worker 155were being run on the compute backbone 300. In this embodiment, the API190 in local mode emulates to the calling application 180 all of thefunctions of the compute backbone 300. Such a local mode of operationmay allow a user 20 and/or applications developer 30 to debug the workermodules 195-1 to 195-N and jobs 182-1 to 182-N it creates, as well asperform regression and other testing and debugging in a localenvironment. Such a feature may form the basis for a contractual servicelevel agreement between a client organization and an administrator forthe compute backbone 300.

In the event a calling application 180 may not be functioning properlywhen run with the compute backbone 300 infrastructure, a user 20 and/orapplications developer 30 may use local mode operation according to oneembodiment to isolate the source of the error. In particular, a user 20and/or applications developer 30 may operate a debugging tool on thelocal computer 100. Moreover, a user 20 and/or applications developer 30may use local mode operation according to one embodiment to verify thatthe compute backbone 300 is performing the functions and delivering thelevel of service the user 20 and/or applications developer 30 expects.

B. Network 200

In the embodiment depicted in FIG. 2, the network 200 is a local areanetwork (LAN). Although the network 200 of the embodiment shown in FIG.2 is a single LAN, in alternative embodiments, connections between localcomputers 100-1 to 100-N and the compute backbone 300 may be ofdifferent types, including a connection over a telephone line, a directconnection, an Internet, a wide area network (WAN), an intranet or othernetwork or combination of the aforementioned connections that is capableof communicating data between hardware and/or software devices. Thenetwork of the embodiment shown in FIG. 2 may have a minimum datatransfer rate of 100 megabytes per second (MBps), and an optimal datatransfer rate of greater than 1 GBps. More than one local computer 100-1to 100-N at a time may communicate with the compute backbone 300 overthe network 200.

In one embodiment, communication over the network 200 between aparticular local computer 100 and the compute backbone 300 may beaccomplished using a communications protocol such as XML/HTTP, simpleobject access protocol (SOAP), XMLRPC, transfer controlprotocol/internet protocol (TCP/IP), file transfer protocol (FTP), orother suitable protocol or combination of protocols.

Using the network 200, a local computer 100 may request information fromthe compute backbone 300 (in particular, the transaction manager 400,described below) by sending a request in a particular communicationprotocol (e.g., a hypertext transfer protocol (HTTP) request). Forexample, a local computer. 100 shown in FIG. 3 may request access to thecompute backbone 300 to process a job 182. When the local computer 100contacts the transaction manager 400 (which, in one embodiment, is aserver) of the compute backbone 300, the local computer 100 asks thetransaction manager 400 for information (e.g., a file of computationresults) by building a message with a compatible language and sendingit. After processing the request, the transaction manager 400 sends therequested information to the local computer 100 in the form of theparticular communication protocol. Software 160 running on the localcomputer 100 may then interpret the information sent by the transactionmanager 400 and provide it to the user 20 (e.g., display it on an outputdevice 140 such as a computer monitor). In one embodiment, thetransaction manager 400 may communicate with a local computer 100 usinga secure protocol (e.g., secure socket layer (SSL)).

C. Compute Backbone 300

According to one embodiment, the compute backbone 300 and acorresponding API 190 enables a number of users 20-1 to 20-N eachrunning, for example, a number of different and completely independentcalling applications to be processed dynamically on a single pool ofdistributed processing resources. Such an embodiment of the computebackbone 300 may collect computation requests from calling applications180-1 to 180-N, invoke those requests on appropriate compute functionsor engines (i.e., workers 155-1 to 155-N), assemble results, and returnthose results to the invoking calling applications 180-1 to 180-N.

As shown in FIG. 2, one embodiment of the compute backbone 300 generallyincludes a transaction manager 400, a central queue 500, a scheduler600, a service manager 700, a number of node computers 800-1 to 800-Nand a global cache 900. As depicted, the compute backbone 300 furtherincludes user interface tools, including an administrative general userinterface (GUI) 1000, which allows a user 20 and/or applicationsdeveloper 30 to monitor and troubleshoot operations of the computebackbone 300. The compute backbone 300 of one embodiment is flexibleenough to allow a request for computation resources equivalent tohundreds of CPUs to be satisfied within minutes. In addition, such acompute backbone 300 may be capable of sustaining input/output datarates sufficient to allow the loading of a global cache 900 of, forexample, 250 megabytes (MB) within approximately ten seconds.

i. Transaction Manager 400

The transaction manager 400 shown in FIGS. 2 and 4 is a gateway to thecompute backbone 300. As such, the transaction manager 400 supportsmultiple types of messaging protocols to enable communication betweenitself and various types of local computers 100-1 to 100-N runningdifferent calling applications 180 created in different programminglanguages. Using the API. 190, the transaction manager 400 alsoguarantees delivery of a compute request from a particular callingapplication 180 on a local computer 100, and performs some transactionalqueue management.

In one embodiment, all communications between a local computer 100 andthe transaction manager 400 are secure and involve an authenticationprocess before access to the compute backbone 300 is granted. Suchauthentication assists the compute backbone 300 (in particular, theservice manager 700 and administrative GUI 1000, discussed below) ingenerating accurate billing information detailing a particular user's 20usage of the resources of the compute backbone 300, and also helps toprevent unauthorized access to the compute backbone 300.

FIG. 4 is a block diagram showing certain components of a transactionmanager 400 according to one embodiment of the present invention. AsFIG. 4 illustrates, the transaction manager 400 of one embodiment is aserver having a central processing unit (CPU) 405 that is incommunication with a number of components by a shared data bus or bydedicated connections—these components include one or more input devices410 (e.g., a CD-ROM drive and/or tape drive) which enable informationand instructions to be input for storage in the transaction manager 400,one or more data storage devices 415, having one or more databases 420defined therein, input/output (I/O) communications ports 425, andsoftware 430. Each I/O communications port 425 has multiplecommunications channels for simultaneous connections with multiple localcomputers 100-1 to 100-N. The software 430 includes an operating system432 and database management programs 434 to store information andperform the operations or transactions described herein. The transactionmanager 400 of one embodiment may access data storage devices 415 whichmay contain a number of databases 420-1 to 420-N. Although theembodiment shown in FIG. 4 depicts the transaction manager 400 as asingle server, a plurality of additional servers (not shown) may also beincluded as part of the transaction manager 400.

The transaction manager 400 of one embodiment is a Unix server whichincludes at least one gigabytes (GB) of memory.

ii. Queue 500

The queue 500 shown in FIG. 2 may perform the following functions: (i)receiving and storing jobs 182-1 to 182-N and task inputs 187-1 to 187-Nfrom the transaction manager 400; (ii) exchanging information with ascheduler 600 such that jobs 182-1 to 182-N are routed to appropriatenode computers 800-1 to 800-N; (iii) sending computation requests tonode computers 800-1 to 800-N; and (iv) providing computation results(i.e., task outputs 189-1 to 189-N) when polled by the transactionmanager 400. Because in some instances task outputs 189-1 to 189-N arenot deleted even after they are retrieved by a calling application 180,it is essential to be able to store large amounts of data effectivelyand efficiently. The queue 500 of one embodiment may be a faulttolerant, persistent storage system responsible for receiving andstoring jobs 182-1 to 182-N and task inputs 187-1 to 187-N from thetransaction manager 400, executing scheduling commands (i.e., routingdecisions) from the scheduler 600 and sending the computation requestsand necessary inputs to the node computers 800-1 to 800-N that performthe computations, and receiving and storing task outputs 189-1 to 189-Nfor retrieval. When requested by a calling application 180, thetransaction manager 400 may return the results of a computation storedin the queue 500 back to the calling applications 180-1 to 180-Ncorresponding to each job 182-1 to 182-N. In one embodiment, allinformation pertinent for a particular job 182 is stored, persistently,in the queue 500 at least until the job 182 has been completed or hasexpired.

The queue 500 of one embodiment may be able to handle large throughputsof requests with low latency. For example, the queue 500 of oneembodiment may be able to process hundreds of thousands of requests perjob 182, each request ranging in size from a few kilobytes to hundredsof kilobytes. For normal load conditions in the compute backbone 300infrastructure of one embodiment, the time it takes to receive arequest, send it to a node computer 800, and retrieve the result shouldtake no more than 500 ms, with 100 ms or less being optimal. The queue500 of one embodiment may be configured to operate with hundreds of nodecomputers 800-1 to 800-N, a number of transaction managers 400-1 to400-N and a number of schedulers 600-1 to 600-N. Hence, theconfiguration of the queue 500 may be closely correlated with that ofthe node computers 800-1 to 800-N, the scheduler 600 and the transactionmanager 400, each of the components adapting to work most efficientlytogether. In such an embodiment, the queue 500 may represent the singlepoint of failure for the compute backbone 300, such that the number ofcomponents downstream of the queue 500 (i.e., node computers 800-1 to800-N and global cache 900) may be increased substantially withoutincreasing the probability of a failure of the entire compute backbone300, even though the mean time to failure of some component downstreamof the queue 500 is likely to decrease as the number of such componentsincreases. With such an arrangement, the user 20 may be guaranteed toobtain a result from the compute backbone 300 even if all componentsdownstream of the fault tolerant queue 500 fail and need to be replaced.In this way, the queue 500 may represent a minimum availability of thecompute backbone 300.

To help ensure that a job 182 sent to the compute backbone 300 isprocessed to completion, the queue 500 may persist certain data,including: (i) meta-information associated with a particular job 182(e.g., job priority and an identification of a worker 155), (ii)optional global data 188 that is to be made available to all of thecomputations in the job 182, which may be supplied at the time the job182 is created or at some later time, (iii) one or more task inputs187-1 to 187-N provided by the transaction manager 400 (the queue 500may optionally delete the task inputs 187-1 to 187-N after thecomputation completes), (iv) task outputs 189-1 to 189-N generated bythe computations (the queue 500 may optionally delete the task outputs189-1 to 189-N after retrieval by the calling application 180), (v) incase of error, the task error output 189, which is stored in place ofthe real task output 189, and (vi) optionally, a computation log for usein debugging and/or verifying the computation results (however, even ifsuch a computation log is generated, the calling application 180 maychoose not to retrieve it). In the embodiment depicted in FIG. 2, thequeue 500 may be, for example, a storage area network (SAN) such as anEMC Celerra File Server, a network attached storage (NAS), or a databaseserver.

iii. Scheduler 600

In one embodiment, the scheduler 600 of the compute backbone 300 mayroute incoming tasks 186 to appropriate workers 155 on the nodecomputers 800-1 to 800-N assigned to a particular user's 20 service.Another function of an embodiment of the scheduler 600 is to allocate anappropriate amount of computing resources to particular jobs 182-1 to182-N based on (1) the amount of resources allocated to a particularservice and (2) the resource requirements of the jobs 182-1 to 182-N (ascommunicated, for example, by the meta-information within each job 182).For example, based on a scheduling algorithm computed by the scheduler600, a particular job 182 may be sent to a particular node computer 800that is available for processing and has been assigned to a service. Thescheduler 600 also may route a specific piece of work to a given nodecomputer 800 upon request (e.g., based on meta-information containedwithin a job 182). In one embodiment, the scheduler 600 may use policyand priority rules to allocate, for a particular session, the resourcesof multiple CPUs in a pool of node computers 800.

As a user 20 monitors the progress of a particular calling application180 running on the compute backbone 200, the user 20 may use thescheduler 600 to dynamically reallocate and/or adjust the computingresources (e.g., CPUs on the node computers 800-1 to 800-N) from one ormore service(s) to another without entirely terminating any of the jobs182-1 to 182-N running on the compute backbone 300. In particular, thescheduler 600 works with the service manager 700 to determine which nodecomputers 800-1 to 800-N and/or other resources can be reallocated toother services.

As shown in FIGS. 2 and 5, the scheduler 600 of one embodiment may be aserver having a CPU 605 that is in communication with a number ofcomponents by a shared data bus or by dedicated connections. Suchcomponents may include one or more input devices 610 (e.g., CD-ROM driveand/or tape drive) which may enable instructions and information to beinput for storage in the scheduler 600, one or more data storage devices615, having one or more databases 620 defined therein, input/output(I/O) communications ports 625, and software 630. Each I/Ocommunications port 625 may have multiple communication channels forsimultaneous connections. The software 630 may include an operatingsystem 632 and data management programs 634 configured to storeinformation and perform the operations or transactions described herein.The scheduler 600 of one embodiment may access data storage devices 615which may contain a number of databases 620-1 to 620-N. Although theembodiment shown in FIG. 2 depicts, the scheduler 600 as a singleserver, a plurality of additional servers (not shown) may also beincluded as part of the scheduler 600. In an alternative embodiment, thescheduler 600 may be one or more personal computers.

Using routing commands from the service manager 700, as well as themeta-information contained in each job 182, the scheduler 600 picks thebest suitable request for a particular node computer 800 and assigns therequest to that node computer 800. In the embodiment shown in FIG. 2,communications between the scheduler 600 and the node computers 800-1 to800-N passes through the queue 500. The scheduler 600 also maycommunicate with the service manager 700 to take appropriate action whena node computer 800 becomes unavailable due to failure, reassignment foruse by another service, suspension, or other reason. In such cases, thescheduler 600 reschedules computations running on the failed orreassigned node computer 800 so that the results from all jobs 182-1 to182-N sent to the compute backbone 300 are eventually completed andreturned to the appropriate calling application 180. Based on certainfactors, including the load on a particular node computer 800, thescheduler 600 may also decide to run more than one computation at a timeon the node computer 800. All the data used by the scheduler 600 may bepersisted in the queue 500, and perhaps also the service manager 700. Inone embodiment, the scheduler 600 may be forced to make, for example,hundreds of scheduling decisions per second. In certain embodiments, thescheduler 600 may also support load balancing, with more than onescheduler 600-1 to 600-N (not shown) being assigned to a particularservice.

The scheduler 600 may change allocations while calling applications180-1 to 180-N are running on the compute backbone 300. The combinationof the scheduler 600, queue 500, service manager 700 and global cache900 may allow dynamic re-allocation without loss of intermediateresults.

iv. Service Manager 700

In one embodiment, the service manager 700 controls how resources on thecompute backbone 300 are allocated to different users 20-1 to 20-N. Inparticular, each node computer 800-1 to 800-N provides the servicemanager 700 with information about its availability at any particulartime. The service manager 700 of one embodiment allocates resources onthe compute backbone 300 to users 20-1 to 20-N or groups of users suchthat failure of one user's 20-1 calling application 180-1 will noteffect another user's 20-2 calling application 180-2 running on thecompute backbone 300, even if both applications 180-1, 180-2 are runningsimultaneously. To achieve this isolation, a “service” is created foreach user 20 or group of users. In one embodiment, the hardware portionof the service is an encapsulation (logical or physical) of all of theresources (e.g., number and identity of node computers 800-1 to 800-N,amount of storage capacity in the global cache 900, amount of databasestorage capacity, etc.) of the compute backbone 300 that are allocatedfor use by a particular user 20 at a particular time. In such anembodiment, the software portion of the service includes the workermodules 195-1 to 195-N that can perform specific computations for aparticular user 20 or group of users. According to one embodiment, whena user 20 seeks to access the compute backbone 300, an administratorallocates resources to the user 20.

At any one time, a particular node computer 800 may be allocated only toone user 20. However, any one node computer 800 allocated to aparticular user 20 may run multiple calling applications 180-1 to 180-Nfrom the user 20 assigned to that node computer 800 during a specifictime period. Furthermore, any one node computer 800 may be allocated todifferent users 20-1 to 20-N during different times of the day or week.For example, one user 20-1 may have access to node computers 800-1 to800-10 from 9:00 a.m. to 11:00 a.m. every morning, while another user20-2 has access to node computers 800-1 to 800-3 from 11:00 a.m. to11:30 a.m. every Monday morning, while yet another user 20-3 has accessto node computers 800-1 to 800-100 from 2:00 p.m. to 2:00 a.m. everyTuesday afternoon and Wednesday morning.

According to one embodiment, a user 20 may be allocated (and thusguaranteed) access to a predetermined number of node computers 800-1 to800-N during a particular time period. In the event that some nodecomputers 800-1 to 800-N have not been allocated to a particular user 20at a particular time, such unused computation resources may be allocatedto one or more users 20-1 to 20-N based on a set of criteria (e.g., oneuser 20-1 may be willing to pay up to a certain amount of money tosecure the unallocated resources at a particular time, but will not beallocated those resources if another user 20-2 is willing to pay more).In an alternative embodiment, more elaborate resource sharing may beavailable such that allocated but unused resources may also bere-allocated based on a set of criteria.

In one embodiment, the service manager 700 monitors and accounts for allresources available on the compute backbone 300 and, in real time,provides the scheduler 600 with information about which services havebeen created and what specific resources have been allocated to eachservice. For example, a user 20 seeking to run a calling application 180using the compute backbone must first be allocated a service, whichincludes, among other things, the processing capability of a specificnumber of specific type(s) of node computers 800-1 to 800-N during aspecific time period.

The service manager 700 may reclaim particular node computers 800-1 to800-N assigned to a particular service for use by a different service.The service manager 700 may also set limits on storage and otherresources available to a service. In one embodiment, the service manager700 collects accounting information from the node computers 800-1 to800-N, and makes that accounting information available for reporting byan administrative GUI 1000 in order to supply users 20-1 to 20-N withbilling and resource utilization information.

The service manager 700 of one embodiment persists at least thefollowing information: (i) a complete inventory of node computers 800-1to 800-N and storage resources, (ii) the resources allocated to eachservice, (iii) the resources requested by each user 20 or group ofusers, and (iv) resource usage and allocation information for use by theadministrative GUI 1000 in creating accounting reports for users 20-1 to20-N.

In one embodiment, the service manager 700 may be in directcommunication with an administrative GUI 1000, the transaction manager400 and the scheduler 600. In addition, the service manager 700 mayreceive information about the status of all node computers 800-1 to800-N on the compute backbone 300 (e.g., failed, unavailable,available). The administrative GUI 1000 and its user interface softwareallow a user 20 to directly interact with the service manager 700 tochange meta-information of a job 182 (e.g., modify the priority) andperform job control actions such as suspending, terminating andrestarting the job 182. In addition, the transaction manager 400 mayinteract with the service manager 700 to programmatically prioritize,schedule and queue the jobs 182-1 to 182-N associated with the callingapplications 180-1 to 180-N sent to the services of each user 20-1 to20-N. Once a service has been created, the service manager 700 commandsthe scheduler 600 to begin scheduling particular jobs 182-1 to 182-N forprocessing on the node computers 800-1 to 800-N assigned to a particularservice.

In the event a node computer 800 fails or becomes otherwise unavailablefor processing, the service manager 700 detects the unavailability ofthat node computer 800 and removes the node computer 800 from theservice allocated to the user 20. In addition, the service manager 700prompts the scheduler 600 to re-queue the scheduling requests madepreviously (and/or being made currently) from the failed or unavailablenode computer 800-1 to another available node computer 800-2.

FIG. 6 is a block diagram showing certain components of a servicemanager 700 according to one embodiment of the present invention. AsFIG. 6 illustrates, the service manager 700 of one embodiment is aserver having a central processing unit (CPU) 705 that is incommunication with a number of components by a shared data bus or bydedicated connections—these components include one or more input devices710 (e.g., CD-ROM drive, tape drive, keyboard, mouse and/or scanner)which enable information and instructions to be input for storage in theservice manager 700, one or more data storage devices 715, having one ormore databases 720 defined therein, input/output (I/O) communicationsports 725, and software 730. Each I/O communications port 725 hasmultiple communications channels for simultaneous connections withmultiple local computers 100-1 to 100-N. The software 730 includes anoperating system 732 and database management programs 734 to storeinformation and perform the operations or transactions described herein.The service manager 700 of one embodiment may access data storagedevices 715 which may contain a number of databases 720-1 to 720-N.Although the embodiment shown in FIG. 6 depicts the service manager 700as a single server, a plurality of additional servers (not shown) mayalso be included as part of the service manager 700.

V. Node Computer 800

In accordance with one embodiment, the node computers 800 performcomputations according to scheduling commands from the scheduler 600.Each node computer 800 may provide the scheduler 600 and/or the servicemanager 700 with an availability status. A launcher 880 may reside oneach node computer 800. On command from the scheduler 600, the launcher880 can launch workers 155-1 to 155-N on the node computer 800 to invokecomputations using the node computer 800 (i.e., provide inputs to theworker 155 and receive outputs from the worker). The launcher 880 mayalso provide a worker 155 with access to infrastructure components ofthe compute backbone 300, such as global cache 900, and to the attendantoperability of the compute backbone 300, such as the ability todistribute computations (as discussed below in section E.). In theembodiment shown in FIG. 2, compute-dense valuation requests areperformed on a pool of physically centralized node computers 800-1 to800-N located remotely from the local computers 100-1 to 100-N. The nodecomputers 800-1 to 800-N need not be identical. In one embodiment, anode computer 800-1 may be, e.g. a Netra st A1000/D1000 made by SunMicrosystems, while another may be, e.g. a cluster of ProLiant BLe-class servers in a rack system made by Compaq.

FIG. 7 is a block diagram illustrating certain components of a nodecomputer 800 according to one embodiment of the present invention. AsFIG. 7 shows, at least one type of node computer 800 is a server havingone or more central processing units (CPU) 820-1 to 820-N incommunication with a number of components by a shared data bus or bydedicated connections—these components include data storage devices 810,one or more input devices 830 (e.g., CD-ROM drive and/or tape drive)which enable information and instructions to be input for storage in thenode computer 800, one or more output devices 840, input/output (I/O)communications ports 850, and software 860. Each I/O communications port850 has multiple communications channels for simultaneous connectionswith the node queue 550, intermediate cache 1050 and global cache 900.The software 860 may include an operating system 870, a launcher 880 andother programs to manage information and perform the operations ortransactions described herein. A node computer 800 of one suchembodiment may be include one or more relatively high-speed CPUs 820-1to 820-N, and a relatively large amount of RAM. However, certainindividual node computers 800-1 to 800-N may have different physicalqualities than others. For example, part of the compute backbone 300 maybe a dedicated cluster. Some or all of the node computers 800-1 to 800-Nof one embodiment may be commodity computing devices, such as relativelyinexpensive, standard items generally available for purchase such thatthey may be replaced easily as technology advancement provides fasterand more powerful processors and larger more efficient data storagedevices.

In one embodiment, the compute backbone 300 infrastructure may haveheterogeneous node computers 800-1 to 800-N the computing resources ofwhich may be made available to a number of local computers 100-1 to100-N running different types of operating systems and completelyindependent applications 180-1 to 180-N. For example, a local computer100 running an operating system by Sun Microsystems may be capable ofaccessing a worker 155 that is written as a MicroSoft Windows dynamiclink library (DLL).

vi. Global Cache 900

Because the compute backbone 300 infrastructure of the embodiment shownin FIG. 2 comprises a closely coupled cluster of resources withrelatively fast interconnections between them, it is possible to giveeach node computer 800-1 to 800-N access to a sufficiently low latencyresource, in which to store its intermediate computation results. Theglobal cache 900 of one embodiment is a persistent storage facilityprovided to the computations being executed on the compute backbone 300which allows those computations to share intermediate data and/or tooptimize database access. In one embodiment, a global cache 900 mayinclude both a hardware configuration and a software component, thesoftware component being configured such that the functionality of theglobal cache 900 will appear to be the same (and operate in the samemanner) regardless of which particular hardware component orconfiguration is being used to implement the cache at a particular time.In one embodiment, a hardware configuration for the global cache 900 mayinclude a number of components, some of which may be located ingeographically separate locations.

Workers 155 running on the compute backbone 300 may use the global cache900 to persist all intermediate data for which the time required toobtain such data (via either computation or accessing a databaseexternal to the compute backbone 300) is at least marginally greaterthan the time it takes to persist it in the global cache 900. Forexample, if it takes 50 ms to retrieve a 1 MB file and 50 ms tode-persist that file from global cache 900, but it takes two seconds ofcomputation time to compute the data stored in the 1 MB file, it may bemore efficient to access the global cache 900 to obtain the file ratherthan computing the results contained in the file. The global cache 900of one embodiment (i) provides workers 155-1 to 155-N a place to storeand retrieve intermediate computation results in a persistent storage,(ii) allows computations to share intermediate data that takes less timeto persist than to re-compute or re-retrieve from an external source,and (iii) provides a means of inter-process communication between theworkers 155-1 to 155-N working on compute requests belonging to the samejob 182. In accordance with one embodiment, data stored in the globalcache 900 is only visible to computations belonging to the same job 182.In accordance with another embodiment, data stored in the global cache900 is visible to computations of multiple jobs 182-1 to 182-N.

The global cache 900 shown in FIG. 2 is implemented as a file system ona storage area network (SAN) or a network attached storage (NAS) with adata rate of, for example, approximately 100-250 MB per second. However,in an alternative embodiment, the global cache 900 may also beimplemented as a database running on a redundant array of independentdisks (RAID) using a 1 gigabit ethernet

vii. Administrative General User Interface 1000

The administrative general user interface (GUI) 1000 of one embodimentmay allow administration of various aspects of the compute backbone 300infrastructure and calling applications 180-1 to 180-N running thereon,including (i) monitoring the operational availability of components ofthe compute backbone 300, (ii) creating a new service and allocatingresources to it, (iii) granting calling applications 180-1 to 180-Nrights to the allocated resources, and (iv) troubleshooting a service inthe event of a failure. In particular, such an administrative GUI 1000may enable a user 20 to deploy worker modules 195-1 to 195-N and otherdata files to a service, and to upload and delete worker modules 195-1to 195-N. For example, using the administrative GUI 1000, a user 20 canobtain accounting, usage and demand pattern information regardingcomputing and storage resources on the compute backbone 300. Periodicreports can be generated to show a user 20 the amount of resources itrequested, was allocated, and utilized for each calling application 180run on the compute backbone 300. Using the administrative GUI 1000, auser 20 may also add, reserve or remove resources used by a service,such as node computers 800-1 to 800-N and data storage.

The administrative GUI 1000 of one embodiment may also enable a user 20to monitor the status of jobs 182-1 to 182-N deployed and/or running onthe node computers 800-1 to 800-N, including the progress of each job182 and its resource utilization. Logs generated by the workers 155-1 to155-N running in a particular job 182 may also be displayed on anadministrative GUI 1000. Furthermore, an authenticated user 20 may beable to cancel or suspend a job 182 through the administrative GUI 1000,as well as change the priority of jobs 182-1 to 182-N already scheduledfor or undergoing computation on the compute backbone 300. A user 20 mayalso cancel or reset an entire service using the administrative GUI 1000of one embodiment, thereby terminating all jobs 182-1 to 182-N runningon the service.

In one embodiment, the administrative GUI 1000 is a personal computercapable of accessing the service manager 700 over a network connectionsuch as local area network or an Internet.

II. Method Embodiments of the Invention

Having described the structure and functional implementation of certainaspects of embodiments of the system 10 of one embodiment, the operationand use of certain embodiments of the system 10 will now be describedwith reference to FIGS. 6-11, and continuing reference to FIGS. 2-5.

A. Method of Developing a Worker Module 195

In one embodiment, an application developer 30 may create a workermodule 195 to be a shared library capable of exposing its main computefunction or engine, called a worker 155, in accordance with a conventionspecified by an API 190. In particular, the workers 155-1 to 155-Nwithin a particular worker module 195 may be uniquely identified by aname/version pair coded into the worker module 195 at the time it iscompiled, and may be discovered by the compute backbone 300 duringdeployment of the worker module 195. In one embodiment, a single workermodule 195 may be configured to expose more than one worker 155-1 to155-N, perhaps simplifying somewhat the development and subsequentdeployment of the worker module 195. In some cases, a user 20 may beable to combine all of the functionality corresponding to a particularcalling application 180 to be deployed on the compute backbone 300 intoa single worker module.

B. Method of Deploying a Worker Module 195 on the Compute Backbone 300

Rather than a traditional executable file, one embodiment of a workermodule 195 deployed on the compute backbone 300 of one embodiment may bea shared library identified by its name, a session enterprise Java bean(EJB) or an executable file compliant with a compute backbone 300. Oncesuch a worker module 195 is developed, a user 20 and/or applicationsdeveloper 30 may access the administrative GUI 1000 to deploy the workermodule 195 onto the compute backbone 300. Alternatively, a worker module195 may be deployed programmatically. According to one embodiment, thecompute backbone 300 checks to ensure that each worker 155 containedwithin a worker module 195 is unique before such a worker 155 may bedeployed.

In such an embodiment, when a node computer 800 on the compute backbone300 receives a job 182 with, for example, a particular computation to beperformed, the node computer 800 may first initialize the worker module195, and then invoke one or more workers 155-1 to 155-N embeddedtherein. This worker module 195 may then remain initialized, ready, forexample, to perform further computations and/or to store intermediatedata directly in global cache 900. Such a worker module 195 need not,however, stay initialized for the duration of an entire job 182. Incertain instances, the compute backbone 300 infrastructure may have anneed to reassign the node computer 800, in which case the worker module195 may be terminated, potentially causing any task 186 currentlyrunning on that node computer 800 to be rescheduled. In the event that ajob 182 is rescheduled, however, the persistent global cache 900 may beavailable to provide intermediate results computed by the node computer800 on which the job 182 was originally running, and to thereby allowthe job 182 to continue computations using those intermediate resultswithout being re-run in its entirety.

Using an administrative GUI 1000, a user 20 and/or applicationsdeveloper 30 may also deploy and manage additional data required by aworker module 195, such as dependent shared libraries or configurationfiles. In one embodiment, any such extra data is to be stored in adirectory accessible to the worker module 195 during runtime, and itslocation is made available to the computation as it is being processed.

One embodiment of the compute backbone 300 may be capable of detectingconflicts between worker modules 195, and alerting users 20-1 to 20-N inorder to prevent deployment of worker modules 195 that export duplicateworkers 155. To help ensure service coherency, worker modules 195-1 to195-N deployed on the compute backbone 300 are to be unique. Accordingto one embodiment, the service manager 700 may verify that not only thename and version number of a particular worker module 195 to be deployedis unique, but also that the functionality of a worker module 195 to bedeployed has not already been deployed on the compute backbone 300.

D. Method of Performing Computations Using a System with a ComputeBackbone 300

Rather than a number of users 20-1 to 20-N each porting an entire longrunning executable computer program to run on a common platform ofprocessors, one method embodiment of the present invention allows a user20 to move just the compute-dense sections of a calling application 180onto a network-accessible computing service, which is the computebackbone 300 described above.

According to one method embodiment of the present invention, certaincomputations may be accomplished by invoking a compute function (i.e.,worker 155) to access at least one input object (i.e., task input 187)in order to create at least one output object (i.e., task output 189).Inputs and outputs may both be objects in a particular programminglanguage.

In this method embodiment, computations performed on the computebackbone 300 may be grouped in sets called jobs 182. The jobs 182 ofsuch an embodiment are to be the smallest units that can be managedeither by a user 20 directly (through the administrative GUI 1000) orprogrammatically. These jobs 182 may have meta-information associatedwith them (e.g., priority and specific resource requirements), whichenable the service manager 700 to assign the job 182 to an appropriatenode computer 800 at an appropriate time. According to this methodembodiment, when creating a job 182, a user 20 and/or applicationdeveloper 30 specifies the worker 155 that will perform computations fora particular job 182.

Once a job 182 is created, a calling application 180 may proceed toschedule computations, with the compute backbone 300, in units calledtasks 186. According to one embodiment, a task 186 includes a task input187 (e.g., an object or structured message) that is accessed by theworker 155 to create a task output 189 (e.g., another object orstructured message). The task output 189 may be returned upon successfulcompletion of the computation. In the case of a failure (i.e., thecomputation was not completed) an error indication may be returned inplace of the task output 189. The user 20 and/or application developer30 may also specify optional global data to be used by the job 182 atthe time the job 182 is created. This global data indicates to thescheduler 600 that it is to be made available to all computations withina job 182.

In accordance with this method embodiment, the calling application 180may indicate to the compute backbone 300 (in particular, the scheduler600) that its tasks 186-1 to 186-N are to be computed eithersynchronously or asynchronously. In a synchronous computation mode, athread in a calling application 180 may first submit to the computebackbone 300 a job 182 containing one or more task 186-1 to 186-N, andthen wait for the results of each successive computation. In anasynchronous computation mode, a calling application 180 may submit thetasks 186-1 to 186-N to the compute backbone 300 and receive back anidentifier, unique in the scope of the particular job 182, which thecalling application 180 or some other application may later use to pollthe compute backbone 300 for results (in particular, the transactionmanager 400 and the queue 500).

In one embodiment, the compute backbone 300 persistently stores in thequeue 500 all task inputs 187-1 to 187-N and task outputs 189-1 to 189-Ninvolved with a particular job 182. In such an embodiment, thisinformation may be deleted only when the job 182 is completed, or whenthe job 182 expires. According to this embodiment, however, theinformation is not to be deleted if the job 182 is terminated due to thefailure or reassignment of the node computer 800 on which it wasrunning. The time of expiration for a job 182 may be specified at thetime the job 182 is created, and may be stored as part of themeta-information for use by the compute backbone (in particular, thescheduler 600 and/or service manager 700).

FIGS. 8 a-8 b illustrate certain operations performed in one embodimentof a method of computing a result using a system 10 as described above.In particular, a worker 155 is deployed on the compute backbone 300.From another point of view, the compute backbone 300 obtains a workermodule 195 which contains a worker 155 (step 1610). Then, the computebackbone 300 obtains one or more jobs 182-1 to 182-N associated with oneor more calling applications 180-1 to 180-N residing on one or morelocal computers 100-1 to 100-N (step 1620). Each job 182-1 to 182-N isstored in the queue 500 prior to processing (step 1625). The computebackbone 300 determines availability of the node computers 800-1 to800-N (step 1630), and schedules the jobs 182-1 to 182-N on availablenode computers 800-1 to 800-N in accordance with any specification ofa-minimum number or type of nodes necessary for the job as specified bymeta-information (step 1640). The jobs 182-1 to 182-N are then sent tothe proper node computers 800-1 to 800-N and initiated or opened onthose nodes (step 1650). When a node computer 800 receives a job 182,the node computer 800 determines whether or not the worker module 195containing the worker 155 to be called has been loaded into the memory820 of the node computer 800 (step 1660). If the worker module 195containing the compute function to be invoked by the job 182 has not yetbeen loaded, the node computer 800 accesses the worker module 195 andloads it into the memory 820 of the node computer 800 (step 1670). Inone embodiment, the job 182 may then receive one or more tasks 186-1 to186-N and, if provided, global data. According to the job 182 of aparticular calling application 180, the node computer 800 then calls theworker 155 to get a result (step 1680). Although the job 182 need notreceive a task 186 at the time of job creation, a task 186 may besupplied at that time. Once the compute function has accessed the taskinput 187 to create the task output 189, the node computer 800 makes thetask output 189 available on the compute backbone 300 (in particular,the queue 500 and/or transaction manager 400) such that the callingapplication 180 is able to retrieve the result (step 1680).

While a job 182 being processed on the compute backbone, access to thejob 182 need not be limited only to the particular calling application180 that initiated it. In one method embodiment, once a job 182 iscreated, other processes may be attached to the job 182 and have accessto the same functionality as the original job 182. According to onemethod embodiment, two or more calling applications 180 may access aparticular job 182. For example, the calling application 180-1 of oneservice may be sending information to a job 182 while the callingapplication 180-2 of a second service is receiving information from thejob 182. In such an embodiment, the user 20 of the calling application180-2 of the second service need not know where the inputs to the job182 originated, what those inputs contain, or where the job 182 is beingprocessed on the compute backbone 300.

In a particular method embodiment, a job 182 is given an identifier atthe time it is created such that the job 182 may be uniquely identifiedby the compute backbone 300. A first calling application 180-1 thensends the job 182 to the compute backbone 300 for processing. Duringsuch processing, a second calling application 180-2 may request accessto the job 182. If the user 20 of the second calling application 180-2has appropriate access (e.g., confirmed by entry of a password assignedto the user 20 of the second calling application 180-2), the secondcalling application 180-2 may be granted access to the job 182.

E. Method of Dividing Computations

The system 10 according to one embodiment of the present invention mayalso enable computations to be distributed and to support certainpatterns of communication and job logic. For example, a job 182 runningon a node computer 800 of the compute backbone 300 may itself create anew “descendant” job, which creates its own task inputs 187-1 to 187-Nand retrieve its own task outputs 189-1 to 189-N. Those descendent jobs182-1 to 182-N created by the “parent” job 182 are new jobs themselves,and may then be scheduled by the scheduler 600 and may be sent forcomputation, for example, to different node computers 800-1 to 800-N,and to a node computer 800 other than the one processing the parent job182. Upon completion of the descendant jobs 182-1 to 182-N, the parentjob 182 may aggregate the results of the descendant jobs 182-1 to 182-Nand use them as task inputs 187-1 to 187-N to in turn create task output189 for the parent job 182.

FIG. 9 illustrates certain operations performed in one embodiment of amethod of computing a result using jobs that recursively divide. Inparticular, a parent job 182 may be scheduled and sent to a nodecomputer 800 by the scheduler 600 (step 1710). The parent job 182 may bereceived by the compute backbone 300 from a calling application 180, ormay itself be a descendant job. Such a parent job 182 may be programmedto include meta-information such that the node computer 800 will (1)divide out any descendant jobs 182-1 to 182-N, each of which then may besent to the scheduler 600 (step 1720), and (2) identify the job as aparent job. Using the meta-information associated with each descendantjob 182-1 to 182-N, the scheduler 600 may prioritize and send thosedescendants to available node computers 800-1 to 800-N for computation(step 1730). In such an embodiment, the scheduler 600 may avoidreassigning the node computer 800 on which a parent job 182 is running(and may avoid otherwise terminating the parent job 182) until alldescendant jobs 182-1 to 182-N have been completed. In this way,although the node computers 800 may be considered volatile resources forpurposes of processing jobs in general (because a node computer runninga job other than a parent job 182 may be re-assigned by the scheduler600 at any time, and the scheduler 600 may re-assign a non-parent job toa new node computer 800 at any time), a node computer processing aparent job 182 is given priority over other node computers until all ofits descendant jobs 182-1 to 182-N have completed.

The node computer 800 may process the descendant job according to one ormore workers 155-1 to 155-N specified by meta-information contained inthe descendant job (step 1740). Upon completion of each descendant job182-1 to 182-N, each node computer 800-1 to 800-N running a descendantjob 182 may make the result from each such job available to the parentjob 182 by storing those results in the queue 500 (step 1750). Inaddition, intermediate and/or final results of each descendant job maybe stored in the global cache 900 for use by other jobs, including otherdescendant jobs and/or the parent job (step 1760). Then, the parent job182 may access the queue 500 and/or global cache 900 to obtain theresults from the descendant jobs 182-1 to 182-N, which may be taskoutputs 189-1 to 189-N of the descendant jobs 182-1 to 182-N, and mayuse them to create its own result (another task output 189) (step 1770).As a further example, the results from the descendant jobs 182-1 to182-N may be sent directly to the parent job 182 without passing throughthe queue 500 and/or global cache 900. The result created by the parentjob 182 then may be sent from the node computer 800 to the transactionmanager 400 for retrieval by the calling application 180 (step 1780).

In one embodiment, the scheduler 600 may contain algorithms whichrecognize meta-information in a parent job 182 that identifies it assuch, and may attempt to ensure that the node computer 800 on which aparent job 182 is running is not interrupted until all of the descendantjobs 182-1 to 182-N have been completed. Furthermore, suchmeta-information may identify a particular worker 155 for use inperforming a computation. If the scheduler 600 must vacate a nodecomputer 800, the scheduler 600 of such an embodiment will endeavor notto vacate a node computer 800 that has parent jobs 182-1 to 182-Nrunning on it. However, if a parent job 182 is prematurely terminated(step 1752), all of its descendants may also be terminated (step 1754).

F. Method of Caching Results

In one embodiment, all processes running on the node computers 800-1 to800-N of the compute backbone 300 have access to the global cache 900.During computation of a particular job 182 on a particular node computer800, intermediate or partial results created by the job 182 may bestored in the global cache 900. For example, a worker module 195 maystore an intermediate result as it computes a task 186. In addition, ajob 182 may store in the global cache 900 data obtained from sourcesexternal to the node computers 800-1 to 800-N. According to thisembodiment, once the intermediate result or other external data isstored in the global cache 900, all jobs 182-1 to 182-N within theproper scope that are running on all node computers 800-1 to 800-N ofthe compute backbone 300 have access to it. The scopes may include (1) aservice-level scope, wherein the cached result is made available to alljobs 182-1 to 182-N within a particular service, (2) a parent-levelscope, wherein the cached result is made available to the parent job andall of its descendant jobs, and (3) a job-level scope, wherein thecached result is made available only to tasks 186-1 to 186-N within oneparticular job 182.

The global cache 900 of one embodiment may have an interface similar toa hash map. This global cache 900 may access data using a key/resultpair, each key being unique within the scope of a job 182.

At the time a job 182 is created, a user 20 and/or applicationsdeveloper 30 may identify intermediate or partial results of a job 182that might be cached in the global cache 900 more quickly than theycould be computed by a particular node computer 800 or retrieved from asource external to the compute backbone 300. For example, a high speednetwork connection may allow a node computer 800 to access previouslycomputed data stored in the global cache 900 more quickly than the nodecomputer 800 can itself compute the cached data. Also at the time a job182 is created, a user 20 and/or application developer 30 may identifydata from sources external to the global cache 900 that might be cachedby a job 182 to reduce contention by other node computers 800 or othercomponents of the compute backbone 300 for the external resource.

FIGS. 10 a and 10 b illustrate certain operations performed in oneembodiment of a method of caching intermediate results. In particular, acalling application 180 may send a job 182 identifying a worker 155 byits name/version pair to the compute backbone 300 (step 1810). Thescheduler 600 may then send the job 182 to an available node computer800 (step 1815). The node computer 800 may then process the job 182 andcreate a result previously identified as a partial or intermediateresult to be made available to other computations (step 1820). The nodecomputer 800 then may send the partial or intermediate result to theglobal cache 900 for storage therein (step 1825). In accordance with oneembodiment, a key/result pair may be assigned to the stored intermediateresult. If a job 182 terminates during computation (e.g., byreassignment of the: node computer to a new service (step 1830) or byfailure of the node computer 800), the scheduler 600 may send the job182 to another available node computer 800-2 (step 1835). The new nodecomputer 800-2 then may access the global cache 900 to retrieveintermediate data computed during the initial processing of the job suchthat the job need not be recomputed in its entirety (step 1840). At somelater time, any job 182-2 running on any node computer 800 can accessthe global cache 900 to retrieve the partial or intermediate result fromthe earlier job 182-1, which may have been computed on a different nodecomputer 800 and may have terminated long ago (step 1845).

According to the method embodiment shown in FIGS. 10 a-10 b, a job 182-2seeking to retrieve a cached result from an earlier job 182-1 maypresent to the global cache 900 a lookup function which is atomicbecause it has both a key and a compute function associated with theresult sought to be retrieved from the global cache 900. In the eventthat the key is found (step 1855), the global cache 900 returns therequested result to the job 182-2. If the key is not found (step 1860),however, the node computer 800 on which the job 182-2 is running maycompute the requested result using the compute function of the lookupfunction. In the event that a subsequent job 182-3 attempts to accessthe result currently being computed, the node computer 800 on which thatsubsequent job 182-3 is being run may be prevented from computing thecompute function and, instead, prompted to wait for the job 182-2computing the result to finish its computation and caching of the result(step 1865). In this embodiment, the job 182 may seek the result of afunction that has been identified as cachable, so that the key andassociated compute function are presented to the cache, hence the globalcache 900 access is atomic from the viewpoint of the worker module.

In accordance with one embodiment, calling one atomic lookup functionmay return several intermediate results at once. In such an embodiment,the lookup function includes a key and a compute function for each ofthe intermediate results called for by the lookup function.

G. Illustrative Computation According to Method Embodiments

To further illustrate both a method of caching intermediate results anda method of computing a result using recursively dividing jobs 182-1 to182-N, consider a calling application 180 programmed to compute thevalue of a portfolio containing one thousand instruments. Consider alsothat the calling application 180 is programmed to reflect the marketenvironment in which the value of the particular portfolio is to bedetermined. Further consider that at least a portion of the marketenvironment must also be established (e.g., certain yield curves must becomputed in order to fully define the market environment).

According to one method embodiment, the calling application 180 mayinvoke a worker 155 called “value portfolio,” and also pass to thecompute backbone 300 a set of inputs representing the market environmentin which the value of the particular portfolio is to be calculated.Next, the “value portfolio” worker 155 may perform some preliminaryyield curve calculations to more fully define the market environment.The results of those preliminary calculations may be stored in theglobal cache 900 and made available to other “value portfolio” workers155-1 to 155-N. Such intermediate results defining the marketenvironment (now stored in global cache 900) may be available to the“value portfolio” worker 155 as well as all other jobs 182-1 to 182-Nrunning on all other node computers 800-1 to 800-N within a particularservice. Then, according to the “value portfolio” worker 155, onethousand separate descendant jobs 182-1 to 182-1000 named, for example,“value instrument no. 1,” “value instrument no. 2,” etc., are dividedout and sent to the scheduler 600 for assignment to an available nodecomputer 800 within the service. The one thousand descendant jobs 182-1to 182-1000 may each be sent to and processed on available nodecomputers 800-1 to 800-N. During processing, each of the descendant jobs182-1 to 182-1000 has access to the market environment results computedearlier and stored in the global cache 900. As a result, the descendantjobs 182-1 to 182-1000 may not need to perform the yield curvecomputation themselves and may not need to contact the callingapplication 180 for such information, but rather, can more quicklyobtain the results of the yield curve computation stored in the globalcache 900. Upon completion of each of the one thousand descendant jobs182-1 to 182-1000, the “value portfolio” job 182 aggregates the outputsfrom the “value instrument” jobs 182-1 to 182-1000 for furthercomputation of a portfolio value result.

H. Method of Troubleshooting/Debugging One Embodiment of a System

One embodiment of the system 10 also has additional functionality thatmay allow a worker 155 to be deployed on a local computer 100 withoutaccessing the compute backbone 300 infrastructure or the network 200. Toallow an applications developer 30 to debug its worker modules 195-1 to195-N locally on its local computer 100 (which, in one embodiment, isthe development host for the applications developer 30), the computebackbone 300 is capable of (i) providing a simplified replica of itself,including an API 190, and (ii) initializing worker modules 195-1 to195-N in the same process space in which the calling application 180resides. Such a capability may enable an applications developer 30 todebug functionality, such as persistence and parameter passing, in anenvironment where the developer 30 has access to all necessaryinformation about both the calling application 180 and the environmenton which it is running (i.e., the replicated functionality of thecompute backbone 300). For example, if a worker module 195 performsproperly on the local computer 100, it will also perform properly whendeployed on the compute backbone 300.

FIG. 11 illustrates certain operations performed in one embodiment of amethod of running a calling application 180 in local mode. For anyparticular calling application 180, an applications developer 30 maycreate both a worker module 195 and one or more jobs 182 (step 1910). Atinitialization, the developer 30 links the calling application 180 tothe API 190 file associated with local mode operation (as opposed to theAPI 190 file associated with network mode operation) (step 1920). TheAPI 190 then loads the worker module 195 into the process space of thelocal computer 100 (step 1930). The API 190 ensures that a replica ofall major functions performed by the compute backbone 300 (e.g.,scheduling, caching, etc.) are loaded into the data storage devices 110-1 to 110-N of the local computer 100 (step 1940). The worker 155 is thenprocessed on the CPU 120 of the local computer 100 (step 1950). Unlikethe parallel computing operation of network mode on the actual computebackbone 300 infrastructure, processing in local mode is accomplishedsequentially, or perhaps concurrently if multithreading is used.

Although illustrative embodiments and example methods have been shownand described herein in detail, it should be noted and will beappreciated by those skilled in the art that there may be numerousvariations and other embodiments which may be equivalent to thoseexplicitly shown and described. For example, the scope of the presentinvention is not necessarily limited in all cases to execution of theaforementioned steps in the order discussed. Unless otherwisespecifically stated, the terms and expressions have been used herein asterms and expressions of description, not of limitation. Accordingly,the invention is not limited by the specific illustrated and describedembodiments and examples (or the terms or expressions used to describethem) but only by the scope of appended claims.

1. A method, comprising: receiving a job for computation by adistributed computing system comprising one or more node computingdevices in communication with a cache; processing, on one of said nodecomputing devices, said job to create an intermediate result for storagein said cache, wherein said intermediate result comprises data wherein atime required to obtain said data by computation or retrieval from adata storage external to said distributed computer system is at leastmarginally greater than that of retrieving said intermediate result fromsaid cache; storing said intermediate result in said cache; andaccessing said cache by presenting a lookup function to said cache,wherein said lookup function comprises a key and a compute functionconfigured to produce said intermediate result, wherein said accessingfurther comprises: determining whether said key is found in said cache;responsive to determining that said key is not found, computing saidcompute function to regenerate said intermediate result; and preventinga second node computing device from computing said compute functionduring said computing said compute function to regenerate saidintermediate result.
 2. The method of claim 1, wherein said storingcomprises assigning a key/result pair to said intermediate result. 3.The method of claim 1, wherein said cache comprises a storage areanetwork.
 4. The method of claim 1, wherein said cache comprises aplurality of geographically separate devices.
 5. The method of claim 1,wherein said cache comprises a database running on a redundant array ofindependent disks.
 6. The method of claim 1, further comprising:reassigning said node computing device processing said job; schedulingcomputation of said job on another node computing device; and accessingsaid cache to retrieve said intermediate result for use in computationof said job on said another node computing device.
 7. The method ofclaim 1, wherein said compute function is computed on at least one ofsaid node computing devices other than said node computing deviceprocessing said job.
 8. The method of claim 1, wherein said receivingcomprises receiving said job from an application running on a localcomputing device.
 9. A distributed computing system, comprising: one ormore node computing devices in communication with a cache; means forreceiving a job for computation by said distributed computing system;means for processing, on one of said node computing devices, said job tocreate an intermediate result for storage in said cache, wherein saidintermediate result comprises data wherein a time required to obtainsaid data by computation or retrieval from a data storage external tosaid distributed computer system is at least marginally greater thanthat of retrieving said intermediate result from said cache; means forstoring said intermediate result in said cache; and means for accessingsaid cache by presenting a lookup function to said cache, wherein saidlookup function comprises a key and a compute function configured toproduce said intermediate result, wherein said means for accessingfurther comprises: means for determining whether said key is found insaid cache; means for computing said compute function to regenerate saidintermediate result in response to a determination that said key is notfound; and means for preventing a second node computing device fromcomputing said compute function during said computing said computefunction to regenerate said intermediate result.
 10. The distributedcomputing system of claim 9, wherein said means for storing comprisesmeans for assigning a key/result pair to said intermediate result. 11.The distributed computing system of claim 9, wherein said cachecomprises a storage area network.
 12. The distributed computing systemof claim 9, wherein cache comprises a plurality of geographicallyseparate devices.
 13. The distributed computing system of claim 9,wherein said cache comprises a database running on a redundant array ofindependent disks.
 14. The distributed computing system of claim 9,further comprising: means for reassigning said node computing deviceprocessing said job; means for scheduling computation of said job onanother node computing device; and means for accessing said cache toretrieve said intermediate result for use in computation of said job onsaid another node computing device.
 15. The distributed computing systemof claim 9, wherein said compute function is computed on at least one ofsaid node computing devices other than said node computing deviceprocessing said job.
 16. The distributed computing system of claim 9,further comprising means for receiving said job from an applicationrunning on a local computing device.